const { api } = require('../../utils/api');

// 模拟API，用于本地开发测试
const mockApi = {
  // 模拟登录API
  login: (code) => {
    return new Promise((resolve) => {
      setTimeout(() => {
        // 生成一个模拟的用户ID
        const userId = 'user_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
        
        resolve({
          code: 0,
          data: {
            token: 'mock_token_' + Date.now(),
            userInfo: {
              id: userId,
              openid: 'mock_openid_' + Math.random().toString(36).substr(2, 9),
              nickname: '测试用户',
              avatar: '',
              phone: ''
            }
          },
          message: '登录成功'
        });
      }, 1000);
    });
  },
  
  // 模拟获取验证码API
  sendVerifyCode: (phone) => {
    return new Promise((resolve) => {
      setTimeout(() => {
        if (phone && phone.length === 11) {
          resolve({
            code: 0,
            data: {
              expireTime: 300 // 5分钟过期
            },
            message: '验证码发送成功'
          });
        } else {
          resolve({
            code: 1,
            message: '手机号格式不正确'
          });
        }
      }, 1000);
    });
  },
  
  // 模拟手机号登录验证API
  verifyPhoneLogin: (phone, code) => {
    return new Promise((resolve) => {
      setTimeout(() => {
        if (phone && phone.length === 11 && code && code.length === 6) {
          // 生成一个模拟的用户ID
          const userId = 'phone_user_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
          
          resolve({
            code: 0,
            data: {
              token: 'mock_phone_token_' + Date.now(),
              userInfo: {
                id: userId,
                openid: 'mock_openid_' + Math.random().toString(36).substr(2, 9),
                nickname: '手机用户',
                avatar: '',
                phone: phone
              }
            },
            message: '登录成功'
          });
        } else {
          resolve({
            code: 1,
            message: '验证码错误或已过期'
          });
        }
      }, 1000);
    });
  }
};

Page({
  data: {
    isAgree: false, // 默认同意协议
    showPhoneModal: false, // 是否显示手机号登录弹窗
    phone: '', // 手机号
    verifyCode: '', // 验证码
    codeSent: false, // 验证码是否已发送
    codeText: '获取验证码', // 验证码按钮文字
    countdown: 60, // 倒计时秒数
    canLogin: false, // 是否可以登录
    fromPage: '' // 来源页面
  },

  onLoad(options) {
    // 记录来源页面，用于登录成功后返回
    if (options.from) {
      this.setData({
        fromPage: options.from
      });
    }
  },

  // 微信快捷登录
  wechatLogin() {
    if (!this.data.isAgree) {
      this.showAgreementTip();
      return;
    }

    wx.showLoading({
      title: '登录中...',
      mask: true
    });

    // 获取用户信息
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: (userProfileRes) => {
        // 使用微信登录
        wx.login({
          success: async (res) => {
            if (res.code) {
              try {
                // 调用后端登录接口，传入code和用户信息
                const result = await api.login({
                  code: res.code,
                  userInfo: userProfileRes.userInfo
                });

                if (result.code == 200 && result.data && result.data.token) {
                  // 登录成功，保存token和用户信息
                  const token = result.data.token;
                  const expireTime = Date.now() + 3 * 24 * 60 * 60 * 1000; // 3天后过期
                  
                  // 保存token和过期时间
                  wx.setStorageSync('token', token);
                  wx.setStorageSync('tokenExpireTime', expireTime);
                  
                  // 保存用户基本信息，确保包含用户ID
                  if (result.data.user) {
                    // 获取用户信息
                    const userInfo = result.data.user;
                    
                    // 添加显著的控制台输出，便于识别用户ID
                    console.log('==================================');
                    console.log('登录成功！当前用户ID:', userInfo.id);
                    console.log('用户信息:', userInfo);
                    console.log('==================================');
                    
                    // 保存到缓存
                    wx.setStorageSync('userInfo', userInfo);
                  }

                  // 登录成功，返回来源页面或用户中心
                  this.loginSuccess();
                } else {
                  this.showError(result.message || '登录失败');
                }
              } catch (error) {
                console.error('登录失败:', error);
                this.showError('登录失败，请重试');
              }
            } else {
              this.showError('获取用户登录态失败');
            }
          },
          fail: () => {
            this.showError('微信登录失败，请重试');
          },
          complete: () => {
            wx.hideLoading();
          }
        });
      },
      fail: (err) => {
        wx.hideLoading();
        this.showError('获取用户信息失败，请重试');
      }
    });
  },

  // 打开手机号登录弹窗
  phoneLogin() {
    if (!this.data.isAgree) {
      this.showAgreementTip();
      return;
    }

    this.setData({
      showPhoneModal: true
    });
  },

  // 关闭弹窗
  closeModal() {
    this.setData({
      showPhoneModal: false,
      phone: '',
      verifyCode: '',
      codeSent: false,
      codeText: '获取验证码',
      canLogin: false
    });
    // 清除可能存在的倒计时
    if (this.countdownTimer) {
      clearInterval(this.countdownTimer);
    }
  },

  // 输入手机号
  inputPhone(e) {
    const phone = e.detail.value;
    this.setData({
      phone,
      canLogin: phone.length === 11 && this.data.verifyCode.length === 6
    });
  },

  // 输入验证码
  inputCode(e) {
    const verifyCode = e.detail.value;
    this.setData({
      verifyCode,
      canLogin: this.data.phone.length === 11 && verifyCode.length === 6
    });
  },

  // 发送验证码
  async sendVerifyCode() {
    const { phone } = this.data;
    
    if (!phone || phone.length !== 11) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '发送中...'
    });

    try {
      // 发送验证码
      // const result = await api.sendVerifyCode(phone);
      const result = await mockApi.sendVerifyCode(phone);

      if (result.code === 0) {
        // 发送成功，开始倒计时
        this.setData({
          codeSent: true,
          codeText: '60s'
        });
        this.startCountdown();
        wx.showToast({
          title: '验证码已发送',
          icon: 'success'
        });
      } else {
        wx.showToast({
          title: result.message || '发送失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('发送验证码失败:', error);
      wx.showToast({
        title: '发送失败，请重试',
        icon: 'none'
      });
    } finally {
      wx.hideLoading();
    }
  },

  // 开始倒计时
  startCountdown() {
    let countdown = this.data.countdown;
    this.countdownTimer = setInterval(() => {
      countdown--;
      if (countdown <= 0) {
        clearInterval(this.countdownTimer);
        this.setData({
          codeSent: false,
          codeText: '重新获取',
          countdown: 60
        });
      } else {
        this.setData({
          codeText: `${countdown}s`
        });
      }
    }, 1000);
  },

  // 手机号登录确认
  async confirmPhoneLogin() {
    const { phone, verifyCode } = this.data;
    
    if (!phone || phone.length !== 11) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      });
      return;
    }

    if (!verifyCode || verifyCode.length !== 6) {
      wx.showToast({
        title: '请输入正确的验证码',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '登录中...',
      mask: true
    });

    try {
      // 验证手机号和验证码
      // const result = await api.verifyPhoneLogin(phone, verifyCode);
      const result = await mockApi.verifyPhoneLogin(phone, verifyCode);

      if (result.code === 0 && result.data && result.data.token) {
        // 登录成功，保存token和用户信息
        const token = result.data.token;
        const expireTime = Date.now() + 3 * 24 * 60 * 60 * 1000; // 3天后过期
        
        // 保存token和过期时间
        wx.setStorageSync('token', token);
        wx.setStorageSync('tokenExpireTime', expireTime);
        
        // 保存用户基本信息
        if (result.data.userInfo) {
          // 确保userInfo中包含id字段
          const userInfo = result.data.userInfo;
          
          // 如果后端返回的是userId而不是id，进行转换
          if (!userInfo.id && userInfo.userId) {
            userInfo.id = userInfo.userId;
          }
          
          // 如果仍然没有id，而有openid，使用openid作为id
          if (!userInfo.id && userInfo.openid) {
            userInfo.id = userInfo.openid;
          }
          
          // 如果还是没有id，则使用手机号作为临时id
          if (!userInfo.id && phone) {
            userInfo.id = 'phone_' + phone;
          }
          
          // 添加显著的控制台输出，便于识别用户ID
          console.log('==================================');
          console.log('手机号登录成功！当前用户ID:', userInfo.id);
          console.log('用户信息:', userInfo);
          console.log('==================================');
          
          // 保存到缓存
          wx.setStorageSync('userInfo', userInfo);
        } else if (result.data.user) {
          // 新格式: 用户信息在result.data.user中
          const userInfo = result.data.user;
          
          // 添加显著的控制台输出，便于识别用户ID
          console.log('==================================');
          console.log('手机号登录成功！当前用户ID:', userInfo.id);
          console.log('用户信息:', userInfo);
          console.log('==================================');
          
          // 保存到缓存
          wx.setStorageSync('userInfo', userInfo);
        }

        // 关闭弹窗
        this.closeModal();

        // 登录成功，返回来源页面或用户中心
        this.loginSuccess();
      } else {
        wx.showToast({
          title: result.message || '验证失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('手机号登录失败:', error);
      wx.showToast({
        title: '登录失败，请重试',
        icon: 'none'
      });
    } finally {
      wx.hideLoading();
    }
  },

  // 切换协议同意状态
  toggleAgreement() {
    this.setData({
      isAgree: !this.data.isAgree
    });
  },

  // 显示协议未同意提示
  showAgreementTip() {
    wx.showToast({
      title: '请先同意用户协议和隐私政策',
      icon: 'none'
    });
  },

  // 查看用户协议
  viewUserAgreement() {
    wx.navigateTo({
      url: '/pages/webview/index?type=agreement'
    });
  },

  // 查看隐私政策
  viewPrivacyPolicy() {
    wx.navigateTo({
      url: '/pages/webview/index?type=privacy'
    });
  },

  // 显示错误提示
  showError(message) {
    wx.showToast({
      title: message,
      icon: 'none'
    });
  },

  // 登录成功后的处理
  loginSuccess() {
    wx.showToast({
      title: '登录成功',
      icon: 'success',
      duration: 1500,
      mask: true,
      success: () => {
        setTimeout(() => {
          // 如果有来源页，则返回来源页
          if (this.data.fromPage) {
            wx.navigateBack({
              delta: 1
            });
          } else {
            // 否则跳转到个人中心
            wx.switchTab({
              url: '/pages/user/index'
            });
          }
        }, 1500);
      }
    });
  }
}); 